home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xpaint-2.1.1 / rw / rwTable.c < prev    next >
C/C++ Source or Header  |  1995-05-03  |  5KB  |  246 lines
  1. /* +-------------------------------------------------------------------+ */
  2. /* | Copyright 1993, David Koblas (koblas@netcom.com)                  | */
  3. /* |                                                                   | */
  4. /* | Permission to use, copy, modify, and to distribute this software  | */
  5. /* | and its documentation for any purpose is hereby granted without   | */
  6. /* | fee, provided that the above copyright notice appear in all       | */
  7. /* | copies and that both that copyright notice and this permission    | */
  8. /* | notice appear in supporting documentation.  There is no           | */
  9. /* | representations about the suitability of this software for        | */
  10. /* | any purpose.  this software is provided "as is" without express   | */
  11. /* | or implied warranty.                                              | */
  12. /* |                                                                   | */
  13. /* +-------------------------------------------------------------------+ */
  14.  
  15. #include <stdio.h>
  16. #include "image.h"
  17. #include "rwTable.h"
  18. #include <string.h>
  19. #include <errno.h>
  20.  
  21. #ifdef MISSING_STDARG_H
  22. #include <varargs.h>
  23. #else
  24. #include <stdarg.h>
  25. #endif
  26.  
  27. #ifndef TRUE
  28. #define TRUE 1
  29. #define FALSE 0
  30. #endif
  31.  
  32. typedef struct {
  33.     char        *name;
  34.     RWreadFunc    read;
  35.     RWwriteFunc    write;
  36.     RWtestFunc    test;
  37. } ImageTypes;
  38.  
  39. static Image    *readMagic(char*);
  40. static char     RWtableMsg[512];
  41.  
  42. /*
  43. **  Define all the read/write functions here.
  44. **    [ unfortunaltly most compilers won't take the
  45. **      the "variable" name version of these. ]
  46. */
  47.  
  48. extern Image    *ReadXBM(char*);
  49. extern Image    *ReadXWD(char*);
  50. extern Image    *ReadPNM(char*);
  51. extern Image    *ReadGIF(char*);
  52. extern Image    *ReadSGI(char*);
  53. extern Image    *ReadXPM(char*);
  54. extern Image    *ReadTIFF(char*);
  55. extern Image    *ReadJPEG(char*);
  56. extern int      WriteXBM(char *, Image *);
  57. extern int      WriteXWD(char *, Image *);
  58. extern int      WritePNM(char *, Image *);
  59. extern int      WriteXPM(char *, Image *);
  60. extern int      WriteGIF(char *, Image *);
  61. extern int      WriteSGI(char *, Image *);
  62. extern int      WriteTIFF(char *, Image *);
  63. extern int      WritePS(char *, Image *);
  64. extern int      TestPNM(char *);
  65. extern int     TestXWD(char *);
  66. extern int    TestXBM(char *);
  67. extern int    TestXPM(char *);
  68. extern int    TestGIF(char *);
  69. extern int    TestSGI(char *);
  70. extern int    TestTIFF(char *);
  71. extern int    TestJPEG(char *);
  72.  
  73. #define DEF_READ_ENTRY    0
  74. #define DEF_WRITE_ENTRY    1
  75.  
  76. static ImageTypes RWtable[] = {
  77.     { "Best Guess", readMagic, NULL  , NULL    },
  78. #ifdef HAVE_TIFF
  79.     { "TIFF Format", ReadTIFF, WriteTIFF, TestTIFF },
  80. #endif
  81.     { "PPM Format", ReadPNM, WritePNM, TestPNM },
  82.     { "GIF Format", ReadGIF, WriteGIF, TestGIF },
  83.     { "XBM Format", ReadXBM, WriteXBM, TestXBM },
  84.     { "PS Format",  NULL,    WritePS,  NULL },
  85. #ifdef HAVE_XPM
  86.     { "XPM Format", ReadXPM, WriteXPM, TestXPM },
  87. #endif
  88.     { "XWD Format", ReadXWD, WriteXWD, TestXWD },
  89. #ifdef HAVE_SGI
  90.     { "SGI Format", ReadSGI, WriteSGI, TestSGI },
  91. #endif
  92. #ifdef HAVE_JPEG
  93.     { "JPEG Format", ReadJPEG, NULL, TestJPEG },
  94. #endif
  95. };
  96.  
  97. #define    NUMBER    (sizeof(RWtable) / sizeof(RWtable[0]))
  98.  
  99. static    char *readList[NUMBER + 1];
  100. static    char *writeList[NUMBER + 1];
  101.  
  102. /*
  103. **  Special reader that uses the above information.
  104. */
  105. static char    *usedMagicReader = NULL;
  106.  
  107. static Image *readMagic(char *file)
  108. {
  109.     extern int    errno;
  110.     int    i;
  111.  
  112.     errno = 0;
  113.  
  114.     for (i = 0; i < NUMBER; i++) {
  115.         if (RWtable[i].read == NULL || RWtable[i].test == NULL)
  116.             continue;
  117.         if (!RWtable[i].test(file))
  118.             continue;
  119.         usedMagicReader = RWtable[i].name;
  120.         return RWtable[i].read(file);
  121.     }
  122.  
  123.     if (errno == 0)
  124.         RWSetMsg("Unknown image format");
  125.  
  126.     return NULL;
  127. }
  128.  
  129. void *RWtableGetReaderID()
  130. {
  131.     return (void*)usedMagicReader;
  132. }
  133.  
  134.  
  135. /*
  136. **  Give a name, return an "opaque" handle to some information
  137. */
  138. void    *RWtableGetEntry(char *name)
  139. {
  140.     int    i;
  141.  
  142.     for (i = 0; i < NUMBER; i++)
  143.         if (strcmp(name, RWtable[i].name) == 0)
  144.             return (void*)&RWtable[i];
  145.     return NULL;
  146. }
  147.  
  148. char    *RWtableGetId(void *v)
  149. {
  150.     ImageTypes    *entry = (ImageTypes*)v;
  151.  
  152.     if (entry == NULL)
  153.         return NULL;
  154.  
  155.     return entry->name;
  156. }
  157.  
  158. RWreadFunc RWtableGetReader(void *entry)
  159. {
  160.     RWtableMsg[0] = '\0';
  161.  
  162.     if (entry == NULL) 
  163.         return RWtable[DEF_READ_ENTRY].read;
  164.  
  165.     return ((ImageTypes *)entry)->read;
  166. }
  167.  
  168. RWwriteFunc RWtableGetWriter(void *entry)
  169. {
  170.     RWtableMsg[0] = '\0';
  171.  
  172.     if (entry == NULL) 
  173.         return RWtable[DEF_WRITE_ENTRY].write;
  174.  
  175.     return ((ImageTypes *)entry)->write;
  176. }
  177.  
  178. char **RWtableGetReaderList()
  179. {
  180.     static int    done = FALSE;
  181.     int        i, idx = 0;
  182.  
  183.     if (!done) {
  184.         for (i = 0; i < NUMBER; i++)
  185.             if (RWtable[i].read != NULL) 
  186.                 readList[idx++] = RWtable[i].name;
  187.         readList[idx++] = NULL;
  188.         done = TRUE;
  189.     }
  190.     return readList;
  191. }
  192.  
  193. char **RWtableGetWriterList()
  194. {
  195.     static int    done = FALSE;
  196.     int        i, idx = 0;
  197.  
  198.     if (!done) {
  199.         for (i = 0; i < NUMBER; i++)
  200.             if (RWtable[i].write != NULL) 
  201.                 writeList[idx++] = RWtable[i].name;
  202.         writeList[idx++] = NULL;
  203.         done = TRUE;
  204.     }
  205.  
  206.     return writeList;
  207. }
  208.  
  209. char *RWGetMsg()
  210. {
  211.     extern char     *sys_errlist[];
  212.     extern int    errno;
  213.  
  214.     if (RWtableMsg[0] == '\0') {
  215.         if (errno == 0)
  216.             return "";
  217. #if defined(__STDC__) && !defined(MISSING_STRERROR)
  218.         return strerror(errno);
  219. #else
  220.         return sys_errlist[errno];
  221. #endif
  222.     }
  223.     return RWtableMsg;
  224. }
  225.  
  226. #ifdef MISSING_STDARG_H
  227. void RWSetMsg(va_alist)
  228. va_dcl
  229. {
  230.     va_list        ap;
  231.     char        *fmt;
  232.  
  233.     va_start(ap);
  234.     fmt = va_arg(ap, char *);
  235.     vsprintf(RWtableMsg, fmt, ap);
  236. }
  237. #else
  238. void RWSetMsg(char *fmt, ...)
  239. {
  240.     va_list        ap;
  241.  
  242.     va_start(ap, fmt);
  243.     vsprintf(RWtableMsg, fmt, ap);
  244. }
  245. #endif
  246.